let p: { name: string, age: number } = {name: 'jack', age: 12};
console.log(p);

class Person {
    name: string; //属性 前面省略了Public关键词
    age: number;
    address: string;

    constructor(public index: string) {
        this.name = index;
        this.age = 12;
        this.address = index;
        console.log('父类构造器');
    }

    run(): void {
        console.log(`${this.index}`);
        console.log('父类方法');
    }

}

// let p2: Person = {name: 'Jack', age: 1, address: '四川省成都市高新区', index: 'ss'};
let p2: Person = new Person('index');
console.log(p2);
p2.run();

class Student extends Person {

    constructor(index: string) {
        super(index);
        console.log('子类构造器');
    }

    run(): void {
        console.log('子类方法');
    }
}

let s: Student = new Student('12');

console.log(s);
s.run();

//public    当前类，子类，以及外部可访问 p.name;
//protected 当前类，子类有访问权限，外部不可访问
//private   当前类有访问权限，子类，外部类无访问权限。

//静态方法，实例方法，多态
class Person2 {

    name: string;

    address: string;

    static set: string;

    run(): void {
        console.log('实例方法，必须依赖于对象的实例化');
    }

    static run1(): void {

        console.log('这是静态方法'+this.set);
    }

}

Person2.set = 'indexs';
Person2.run1();

//多态，父类定义一个方法不去实现，子类去实现，每一个子类有不同的表现
//typescript中的抽象类，它是提供其他类继承的基础，不能被直接实例化
//用abstract关键字定义抽象方法，抽象类中的抽象方法不包含具体实现必须在派生类中实现
//abstract抽象方法只能放在抽象类里面
//  抽象类和抽象方法定义标准，基类中必须实现包含这个方法